"""
测试重写后的XML_Utils功能，使用lxml处理复杂命名空间
"""

from com.tools.Xml_Utils.xml_utils import XmlUtils


def test_complex_namespace_xml():
    """
    测试处理复杂命名空间的XML
    """
    print("测试处理复杂命名空间的XML:")
    
    # 复杂命名空间XML示例
    complex_xml = '''<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:test="http://www.baidu.coom">
    <xs:element name="root" xmlns:header="http://test.header.com">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="child" type="xs:string" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>'''
    
    print("原始XML:")
    print(complex_xml)
    
    # 加载XML
    xml_obj = XmlUtils(xml_string=complex_xml)
    
    # 测试命名空间解析
    print("\n测试命名空间解析:")
    namespaces = xml_obj.get_namespaces()
    print(f"解析到的命名空间: {namespaces}")
    
    # 验证关键命名空间
    assert "xs" in namespaces
    assert namespaces["xs"] == "http://www.w3.org/2001/XMLSchema"
    assert "test" in namespaces
    assert namespaces["test"] == "http://www.baidu.coom"
    
    # 测试元素查找
    print("\n测试元素查找:")
    
    # 查找根元素
    root_element = xml_obj.find_element(".//xs:element[@name='root']")
    print(f"找到root元素: {root_element is not None}")
    assert root_element is not None
    
    # 获取root元素的属性
    root_name = xml_obj.get_element_attribute(".//xs:element[@name='root']", "name")
    print(f"root元素的name属性: {root_name}")
    assert root_name == "root"
    
    # 查找child元素
    child_elements = xml_obj.find_elements(".//xs:element[@name='child']")
    print(f"找到{len(child_elements)}个child元素")
    assert len(child_elements) == 1
    
    # 获取child元素的属性
    child_name = xml_obj.get_element_attribute(".//xs:element[@name='child']", "name")
    child_type = xml_obj.get_element_attribute(".//xs:element[@name='child']", "type")
    child_max_occurs = xml_obj.get_element_attribute(".//xs:element[@name='child']", "maxOccurs")
    
    print(f"child元素的name属性: {child_name}")
    print(f"child元素的type属性: {child_type}")
    print(f"child元素的maxOccurs属性: {child_max_occurs}")
    
    assert child_name == "child"
    assert child_type == "xs:string"
    assert child_max_occurs == "unbounded"
    
    # 测试获取元素命名空间
    print("\n测试获取元素命名空间:")
    root_namespaces = xml_obj.get_element_namespaces(".//xs:element[@name='root']")
    print(f"root元素的命名空间: {root_namespaces}")
    assert "header" in root_namespaces
    assert root_namespaces["header"] == "http://test.header.com"
    
    print("复杂命名空间XML测试通过!")


def test_add_custom_namespaces():
    """
    测试添加自定义命名空间
    """
    print("\n\n测试添加自定义命名空间:")
    
    # 创建简单的XML
    xml_obj = XmlUtils.create_empty_xml("root")
    
    # 添加带命名空间的元素
    print("1. 添加带命名空间的元素:")
    custom_element = xml_obj.add_element_with_namespace(
        ".", 
        "customElement", 
        "custom", 
        "http://example.com/custom",
        "自定义内容",
        {"id": "123"}
    )
    
    if custom_element is not None:
        print("成功添加带命名空间的元素")
    else:
        print("添加带命名空间的元素失败")
    
    # 验证命名空间
    namespaces = xml_obj.get_namespaces()
    print(f"当前命名空间: {namespaces}")
    assert "custom" in namespaces
    assert namespaces["custom"] == "http://example.com/custom"
    
    # 测试添加带命名空间的属性
    print("\n2. 添加带命名空间的属性:")
    attr_result = xml_obj.add_attribute_with_namespace(
        ".//custom:customElement", 
        "customAttr", 
        "自定义属性值",
        "attr", 
        "http://example.com/attr"
    )
    
    print(f"添加带命名空间属性结果: {attr_result}")
    assert attr_result == True
    
    # 验证属性
    attr_value = xml_obj.get_element_attribute(".//custom:customElement", "{http://example.com/attr}customAttr")
    print(f"带命名空间的属性值: {attr_value}")
    assert attr_value == "自定义属性值"
    
    # 验证元素文本
    element_text = xml_obj.get_element_text(".//custom:customElement")
    print(f"元素文本: {element_text}")
    assert element_text == "自定义内容"
    
    # 验证元素属性
    element_id = xml_obj.get_element_attribute(".//custom:customElement", "id")
    print(f"元素id属性: {element_id}")
    assert element_id == "123"
    
    print("自定义命名空间测试通过!")


def test_xml_modification():
    """
    测试XML修改功能
    """
    print("\n\n测试XML修改功能:")
    
    # 原始XML
    original_xml = '''<?xml version="1.0" encoding="UTF-8"?>
<root>
    <element id="1">原始内容</element>
</root>'''
    
    xml_obj = XmlUtils(xml_string=original_xml)
    
    # 修改元素文本
    print("1. 修改元素文本:")
    update_result = xml_obj.set_element_text("//element[@id='1']", "修改后的内容")
    print(f"修改文本结果: {update_result}")
    assert update_result == True
    
    # 验证修改结果
    new_text = xml_obj.get_element_text("//element[@id='1']")
    print(f"新文本内容: {new_text}")
    assert new_text == "修改后的内容"
    
    # 添加带命名空间的属性
    print("\n2. 添加带命名空间的属性:")
    attr_result = xml_obj.add_attribute_with_namespace(
        "//element[@id='1']", 
        "newAttr", 
        "新属性值",
        "ns", 
        "http://example.com/ns"
    )
    
    print(f"添加命名空间属性结果: {attr_result}")
    assert attr_result == True
    
    # 验证属性
    attr_value = xml_obj.get_element_attribute("//element[@id='1']", "{http://example.com/ns}newAttr")
    print(f"新属性值: {attr_value}")
    assert attr_value == "新属性值"
    
    # 添加带命名空间的子元素
    print("\n3. 添加带命名空间的子元素:")
    child_element = xml_obj.add_element_with_namespace(
        "//element[@id='1']", 
        "child", 
        "childns", 
        "http://example.com/child",
        "子元素内容"
    )
    
    if child_element is not None:
        print("成功添加带命名空间的子元素")
    else:
        print("添加带命名空间的子元素失败")
    
    # 验证子元素
    child_text = xml_obj.get_element_text(".//childns:child")
    print(f"子元素文本: {child_text}")
    assert child_text == "子元素内容"
    
    print("XML修改功能测试通过!")


def test_to_string_functionality():
    """
    测试转换为字符串功能
    """
    print("\n\n测试转换为字符串功能:")
    
    # 创建带命名空间的XML
    xml_obj = XmlUtils.create_empty_xml("root")
    
    # 添加命名空间元素
    xml_obj.add_element_with_namespace(
        ".", 
        "testElement", 
        "test", 
        "http://example.com/test",
        "测试内容"
    )
    
    # 转换为字符串
    xml_string = xml_obj.to_string(pretty_print=True)
    print("XML字符串:")
    print(xml_string)
    
    # 验证关键内容
    assert "testElement" in xml_string
    assert "http://example.com/test" in xml_string
    assert "测试内容" in xml_string
    
    print("转换为字符串功能测试通过!")


if __name__ == "__main__":
    test_complex_namespace_xml()
    test_add_custom_namespaces()
    test_xml_modification()
    test_to_string_functionality()
    print("\n\n所有测试通过!")